// 聊天管理相关功能（设置目标、加载历史、清理消息等）
import { Ref } from 'vue';
import { isTauri, storageGet, storageSet } from '../services/secure-storage';
import type { Message } from './chat-types';

/**
 * 设置聊天目标
 */
export async function setTarget(
  targetId: string,
  type: 'User' | 'Group',
  currentTargetId: Ref<string | null>,
  targetType: Ref<'User' | 'Group'>
): Promise<void> {
  let newTargetId = String(targetId).trim();
  const newTargetType = type;
  
  // 对于群组，统一移除 group_ 前缀
  if (type === 'Group') {
    newTargetId = newTargetId.replace(/^group_/i, '');
  } else if (type === 'User') {
    // 对于单聊，如果 newTargetId 是用户名，尝试转换为 open_id
    const isNumeric = /^\d+$/.test(newTargetId);
    const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(newTargetId);
    
    if (!isNumeric && !isUUID) {
      // 可能是用户名，尝试通过 API 获取用户的 open_id
      try {
        const { getUser } = await import('../services/message');
        const userInfo = await getUser(newTargetId);
        if (userInfo && userInfo.open_id) {
          console.log('将用户名转换为 open_id:', newTargetId, '->', userInfo.open_id);
          newTargetId = userInfo.open_id;
        } else if (userInfo && userInfo.id) {
          console.log('使用用户 id:', newTargetId, '->', userInfo.id);
          newTargetId = userInfo.id;
        }
      } catch (error) {
        console.log('无法获取用户信息，使用原值:', newTargetId, error);
      }
    }
  }
  
  // 如果目标没有变化，不需要重新加载
  if (currentTargetId.value === newTargetId && targetType.value === newTargetType) {
    console.log('聊天目标未变化，跳过加载');
    return;
  }
  
  currentTargetId.value = newTargetId;
  targetType.value = newTargetType;
  
  console.log('设置聊天目标:', {
    targetId: currentTargetId.value,
    type: targetType.value,
  });
  
  // 注意：这里不自动加载历史消息，因为：
  // 1. 历史消息应该从本地缓存加载（在初始化时已完成）
  // 2. 如果需要从后端加载，应该在组件中显式调用 loadHistory
  // 3. 这样可以避免每次切换聊天目标时都请求后端
}

/**
 * 加载历史消息
 */
export async function loadHistory(_targetId: string, _before?: number): Promise<Message[]> {
  // TODO: 从后端API加载历史消息
  return [];
}

/**
 * 清空当前用户的所有消息缓存
 */
export async function clearCurrentUserMessagesCache(
  messages: Ref<Message[]>
): Promise<{ success: boolean; storageKey: string; deletedMessageCount: number }> {
  try {
    const currentOpenId = isTauri()
      ? await storageGet('openId')
      : localStorage.getItem('openId');
    
    if (!currentOpenId) {
      console.warn('⚠️ 无法获取当前用户的 open_id，无法清空消息缓存');
      throw new Error('无法获取当前用户的 open_id，请先登录');
    }
    
    const storageKey = `chat_messages_${currentOpenId}`;
    
    console.log('🗑️ 开始清空当前用户的消息缓存:', {
      storageKey,
      currentOpenId,
      currentMessageCount: messages.value.length
    });
    
    // 删除存储文件
    if (isTauri()) {
      const { secureStoreRemove } = await import('../services/secure-storage');
      await secureStoreRemove(storageKey);
      localStorage.removeItem(storageKey);
      console.log('✅ 已删除 Tauri 安全存储中的消息缓存');
    } else {
      localStorage.removeItem(storageKey);
      console.log('✅ 已删除 localStorage 中的消息缓存');
    }
    
    // 清空内存中的消息列表
    const deletedCount = messages.value.length;
    messages.value = [];
    
    console.log('✅ 清空消息缓存完成:', {
      storageKey,
      deletedMessageCount: deletedCount,
      note: '已删除存储文件和内存中的消息'
    });
    
    return {
      success: true,
      storageKey,
      deletedMessageCount: deletedCount
    };
  } catch (error) {
    console.error('❌ 清空消息缓存失败:', error);
    throw error;
  }
}

/**
 * 清空特定用户的聊天记录
 */
export async function clearUserMessages(
  targetUserId: string,
  alternativeIds: string[] | undefined,
  messages: Ref<Message[]>,
  currentTargetId: Ref<string | null>,
  currentUserId: Ref<string | null>,
  getMessagesStorageKey: () => Promise<string>,
  saveMessagesToStorage: () => Promise<void>
): Promise<number> {
  try {
    const targetUserIdStr = String(targetUserId);
    
    // 收集所有可能的用户标识符
    const targetIds = new Set<string>([targetUserIdStr]);
    if (alternativeIds) {
      alternativeIds.forEach(id => targetIds.add(String(id)));
    }
    
    const currentUserIdForLog = currentUserId.value || '未知';
    console.log(`清空聊天记录 - 当前用户: ${currentUserIdForLog}`);
    console.log('清空聊天记录 - 目标用户标识符:', Array.from(targetIds));
    console.log('清空聊天记录 - 当前消息总数:', messages.value.length);
    
    // 从消息数组中删除与该用户相关的所有消息
    const beforeCount = messages.value.length;
    const messagesToDelete: Message[] = [];
    
    messages.value = messages.value.filter(msg => {
      const fromId = String(msg.from_user_id || '');
      const toId = String(msg.to_user_id || '');
      
      // 检查是否是群组消息
      const isGroupMessage = msg.chat_type === 2;
      
      // 检查是否匹配目标
      let shouldDelete = false;
      
      if (isGroupMessage) {
        // 群组消息：检查 to_user_id 是否匹配群组ID
        const msgGroupId = toId.replace('group_', '').trim();
        const targetGroupId = targetUserIdStr.replace('group_', '').trim();
        shouldDelete = msgGroupId === targetGroupId;
      } else {
        // 单聊消息：按原来的逻辑处理
        if (msg.isReceived) {
          // 接收的消息：发送者是否是目标用户
          shouldDelete = targetIds.has(fromId);
        } else {
          // 发送的消息：接收者是否是目标用户
          shouldDelete = targetIds.has(toId);
        }
      }
      
      if (shouldDelete) {
        messagesToDelete.push(msg);
        return false; // 删除这条消息
      }
      return true; // 保留这条消息
    });
    
    const deletedCount = beforeCount - messages.value.length;
    console.log(`清空当前用户(${currentUserIdForLog})本地存储中与 ${targetUserIdStr} 相关的聊天记录，删除了 ${deletedCount} 条消息`);
    
    if (deletedCount === 0) {
      console.warn('警告：没有删除任何消息！可能的原因：');
      console.warn('1. 目标标识符与消息中的标识符不匹配');
      console.warn('2. 目标标识符列表:', Array.from(targetIds));
    }
    
    // 保存更新后的消息到存储
    const storageKey = await getMessagesStorageKey();
    console.log(`准备保存到当前用户(${currentUserIdForLog})的存储键:`, storageKey, '消息数量:', messages.value.length);
    
    await saveMessagesToStorage();
    
    // 验证保存是否成功
    try {
      const saved = await storageGet(storageKey);
      if (saved) {
        const savedMessages = JSON.parse(saved);
        console.log('验证保存结果 - 存储中的消息数:', savedMessages.length, '内存中的消息数:', messages.value.length);
        if (savedMessages.length !== messages.value.length) {
          console.warn('警告：保存的消息数量与内存中的不一致！');
          const value = JSON.stringify(messages.value);
          if (isTauri()) {
            await storageSet(storageKey, value);
          } else {
            localStorage.setItem(storageKey, value);
          }
          console.log('已强制重新保存消息');
        } else {
          console.log('保存验证成功：消息数量一致');
        }
      } else {
        console.warn('警告：保存后无法读取存储，可能保存失败！');
        if (messages.value.length > 0) {
          const value = JSON.stringify(messages.value);
          if (isTauri()) {
            await storageSet(storageKey, value);
          } else {
            localStorage.setItem(storageKey, value);
          }
          console.log('已重新保存消息（存储为空的情况）');
        }
      }
    } catch (verifyError) {
      console.error('验证保存结果时出错:', verifyError);
    }
    
    console.log(`已更新当前用户(${currentUserIdForLog})的持久化存储中的聊天记录（已删除与 ${targetUserIdStr} 相关的消息）`);
    
    // 如果当前正在与该用户聊天，清空当前目标
    if (currentTargetId.value && targetIds.has(String(currentTargetId.value))) {
      currentTargetId.value = null;
    }
    
    return deletedCount;
  } catch (error) {
    console.error('清空用户聊天记录失败:', error);
    throw error;
  }
}

